export const MathsData = [
    {
        key: 1,
        name: "add",
        remark: "两数求和",
        use: "_.add(augend, addend)",
        description: `
            两个数相加。
        `,
        argument: `
1.augend (number): 相加的第一个数。
2.addend (number): 相加的第二个数。
        `,
        return: "(number): 返回总和。",
        case: `
_.add(6, 4);
// => 10
        `,
    },
    {
        key: 2,
        name: "ceil",
        remark: "根据精度向上取舍",
        use: "_.ceil(number, [precision=0])",
        description: `
            根据 precision（精度） 向上舍入 number。（注： precision（精度）可以理解为保留几位小数。）
        `,
        argument: `
1.number (number): 要向上舍入的值。
2.[precision=0] (number): 向上舍入的的精度。
        `,
        return: "(number): 返回向上舍入的值。",
        case: `
_.ceil(4.006);
// => 5

_.ceil(6.004, 2);
// => 6.01

_.ceil(6040, -2);
// => 6100
        `,
    },
    {
        key: 3,
        name: "divide",
        remark: "两数相除",
        use: "_.divide(dividend, divisor)",
        description: `
            两个数相除。
        `,
        argument: `
1.dividend (number): 相除的第一个数。
2.divisor (number): 相除的第二个数。
        `,
        return: "(number): 返回商数。",
        case: `
_.divide(6, 4);
// => 1.5
        `,
    },
    {
        key: 4,
        name: "floor",
        remark: "根据精度向下取舍",
        use: "_.floor(number, [precision=0])",
        description: `
            根据 precision（精度） 向下舍入 number。（注： precision（精度）可以理解为保留几位小数。）
        `,
        argument: `
1.number (number): 要向下舍入的值。
2.[precision=0] (number): 向下舍入的精度。
        `,
        return: "(number): 返回向下舍入的值。",
        case: `
_.floor(4.006);
// => 4

_.floor(0.046, 2);
// => 0.04

_.floor(4060, -2);
// => 4000
        `,
    },
    {
        key: 5,
        name: "max",
        remark: "返回数组中最大值",
        use: "_.max(array)",
        description: `
            计算 array 中的最大值。 如果 array 是 空的或者假值将会返回 undefined。
        `,
        argument: `
array (Array): 要迭代的数组。
        `,
        return: "(*): 返回最大的值。",
        case: `
_.max([4, 2, 8, 6]);
// => 8

_.max([]);
// => undefined
        `,
    },
    {
        key: 6,
        name: "maxBy",
        remark: "先处理数组元素再取最大值",
        use: "_.maxBy(array, [iteratee=_.identity])",
        description: `
            这个方法类似_.max 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。
        `,
        argument: `
1.array (Array): 要迭代的数组。
2.[iteratee=_.identity] (Function): 调用每个元素的迭代函数。
        `,
        return: "(*): 返回最大的值。",
        case: `
var objects = [{ 'n': 1 }, { 'n': 2 }];
 
_.maxBy(objects, function(o) { return o.n; });
// => { 'n': 2 }
 
// The _.property iteratee shorthand.
_.maxBy(objects, 'n');
// => { 'n': 2 }
        `,
    },
    {
        key: 7,
        name: "mean",
        remark: "求平均值",
        use: "_.mean(array)",
        description: `
            计算 array 的平均值。
        `,
        argument: `
array (Array): 要迭代的数组。
        `,
        return: "(number): 返回平均值。",
        case: `
_.mean([4, 2, 8, 6]);
// => 5
        `,
    },
    {
        key: 8,
        name: "meanBy",
        remark: "可对对象数组的某一项属性进行取平均值",
        use: "_.meanBy(array, [iteratee=_.identity])",
        description: `
            这个方法类似_.mean， 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。
        `,
        argument: `
1.array (Array): 要迭代的数组。
2.[iteratee=_.identity] (Function): 调用每个元素的迭代函数。
        `,
        return: "(number): 返回平均值。",
        case: `
var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
 
_.meanBy(objects, function(o) { return o.n; });
// => 5
 
// The _.property iteratee shorthand.
_.meanBy(objects, 'n');
// => 5
        `,
    },
    {
        key: 9,
        name: "min",
        remark: "计算数组最小值",
        use: "_.min(array)",
        description: `
            计算 array 中的最小值。 如果 array 是 空的或者假值将会返回 undefined
        `,
        argument: `
array (Array): 要迭代的数组。
        `,
        return: "(*): 返回最小的值。",
        case: `
_.min([4, 2, 8, 6]);
// => 2

_.min([]);
// => undefined
        `,
    },
    {
        key: 10,
        name: "minBy",
        remark: "可对对象数组的某一项属性进行取最小值",
        use: "_.minBy(array, [iteratee=_.identity])",
        description: `
            这个方法类似_.min 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。
        `,
        argument: `
1.array (Array): 要迭代的数组。
2.[iteratee=_.identity] (Function): 调用每个元素的迭代函数。
        `,
        return: "(*): 返回最小的值。",
        case: `
var objects = [{ 'n': 1 }, { 'n': 2 }];
 
_.minBy(objects, function(o) { return o.n; });
// => { 'n': 1 }
 
// The _.property iteratee shorthand.
_.minBy(objects, 'n');
// => { 'n': 1 }
        `,
    },
    {
        key: 11,
        name: "multiply",
        remark: "两个数相乘",
        use: "_.multiply(multiplier, multiplicand)",
        description: `
            两个数相乘。
        `,
        argument: `
1.augend (number): 相乘的第一个数。
2.addend (number): 相乘的第二个数。
        `,
        return: "(number): 返回乘积。",
        case: `
_.multiply(6, 4);
// => 24
        `,
    },
    {
        key: 12,
        name: "round",
        remark: "根据精度进行四舍五入",
        use: "_.round(number, [precision=0])",
        description: `
            根据 precision（精度） 四舍五入 number。
        `,
        argument: `
1.number (number): 要四舍五入的数字。
2.[precision=0] (number): 四舍五入的精度。
        `,
        return: "(number): 返回四舍五入的数字。",
        case: `
_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100
        `,
    },
    {
        key: 13,
        name: "subtract",
        remark: "两数相减",
        use: "_.subtract(minuend, subtrahend)",
        description: `
            两数相减。
        `,
        argument: `
1.minuend (number): 相减的第一个数。
2.subtrahend (number): 相减的第二个数。
        `,
        return: "(number): 返回差。",
        case: `
_.subtract(6, 4);
// => 2
        `,
    },
    {
        key: 14,
        name: "sum",
        remark: "数组求和",
        use: "_.sum(array)",
        description: `
            计算 array 中值的总和
        `,
        argument: `
array (Array): 要迭代的数组。
        `,
        return: "(number): 返回总和。",
        case: `
_.sum([4, 2, 8, 6]);
// => 20
        `,
    },
    {
        key: 15,
        name: "sumBy",
        remark: "可对对象数组的某一项属性进行求和",
        use: "_.sumBy(array, [iteratee=_.identity])",
        description: `
            这个方法类似_.summin 除了它接受 iteratee 来调用 array中的每一个元素，来生成其值排序的标准。 iteratee 会调用1个参数: (value) 。
        `,
        argument: `
1.array (Array): 要迭代的数组。
2.[iteratee=_.identity] (Function): 调用每个元素的迭代函数。
        `,
        return: "(number): 返回总和。",
        case: `
var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
 
_.sumBy(objects, function(o) { return o.n; });
// => 20
 
// The _.property iteratee shorthand.
_.sumBy(objects, 'n');
// => 20
        `,
    },
    {
        key: 16,
        name: "inRange",
        remark: "判断值是不是在范围内返回boolean值",
        use: "_.inRange(number, [start=0], end)",
        description: `
            检查 n 是否在 start 与 end 之间，但不包括 end。 如果 end 没有指定，那么 start 设置为0。 如果 start 大于 end，那么参数会交换以便支持负范围。
        `,
        argument: `
1.number (number): 要检查的值。
2.[start=0] (number): 开始范围。
3.end (number): 结束范围。
        `,
        return: "(boolean): 如果number在范围内 ，那么返回true，否则返回 false。",
        case: `
_.inRange(3, 2, 4);
// => true

_.inRange(4, 8);
// => true

_.inRange(4, 2);
// => false

_.inRange(2, 2);
// => false

_.inRange(1.2, 2);
// => true

_.inRange(5.2, 4);
// => false

_.inRange(-3, -2, -6);
// => true
        `,
    },
    {
        key: 17,
        name: "clamp",
        remark: "返回限制范围的数据",
        use: "_.clamp(number, [lower], upper)",
        description: `
            返回限制在 lower 和 upper 之间的值。
        `,
        argument: `
1.number (number): 被限制的值。
2.[lower] (number): 下限。
3.upper (number): 上限。
        `,
        return: "(number): 返回被限制的值。",
        case: `
_.clamp(-10, -5, 5);
// => -5

_.clamp(10, -5, 5);
// => 5
        `,
    },
    {
        key: 18,
        name: "random",
        remark: "返回一个指定范围内的随机数，可以设置是否为浮点数",
        use: "_.random([lower=0], [upper=1], [floating])",
        description: `
            产生一个包括 lower 与 upper 之间的数。 如果只提供一个参数返回一个0到提供数之间的数。 如果 floating 设为 true，或者 lower 或 upper 是浮点数，结果返回浮点数。注意: JavaScript 遵循 IEEE-754 标准处理无法预料的浮点数结果。       `,
        argument: `
1.[lower=0] (number): 下限。
2.[upper=1] (number): 上限。
3.[floating] (boolean): 指定是否返回浮点数。
        `,
        return: "(number): 返回随机数。",
        case: `
_.random(0, 5);
// => an integer between 0 and 5

_.random(5);
// => also an integer between 0 and 5

_.random(5, true);
// => a floating-point number between 0 and 5

_.random(1.2, 5.2);
// => a floating-point number between 1.2 and 5.2
        `,
    },
];